home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 21 / AACD 21.iso / AACD / Utilities / Ghostscript / src / gsropt.h < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-01  |  7.5 KB  |  220 lines
  1. /* Copyright (C) 1995, 2000 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of AFPL Ghostscript.
  4.   
  5.   AFPL Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author or
  6.   distributor accepts any responsibility for the consequences of using it, or
  7.   for whether it serves any particular purpose or works at all, unless he or
  8.   she says so in writing.  Refer to the Aladdin Free Public License (the
  9.   "License") for full details.
  10.   
  11.   Every copy of AFPL Ghostscript must include a copy of the License, normally
  12.   in a plain ASCII text file named PUBLIC.  The License grants you the right
  13.   to copy, modify and redistribute AFPL Ghostscript, but only under certain
  14.   conditions described in the License.  Among other things, the License
  15.   requires that the copyright notice and this notice be preserved on all
  16.   copies.
  17. */
  18.  
  19. /*$Id: gsropt.h,v 1.3 2000/09/19 19:00:32 lpd Exp $ */
  20. /* RasterOp / transparency type definitions */
  21.  
  22. #ifndef gsropt_INCLUDED
  23. #  define gsropt_INCLUDED
  24.  
  25. /*
  26.  * This file defines the types for some library extensions that are
  27.  * motivated by PCL5 and also made available for PostScript:
  28.  * RasterOp, source and pattern white-pixel transparency, and
  29.  * per-pixel "render algorithm" information.
  30.  */
  31.  
  32. /*
  33.  * Define whether we implement transparency correctly, or whether we
  34.  * implement it as documented in the H-P manuals.
  35.  */
  36. #define TRANSPARENCY_PER_H_P
  37.  
  38. /*
  39.  * By the magic of Boolean algebra, we can operate on the rop codes using
  40.  * Boolean operators and get the right result.  E.g., the value of
  41.  * (rop3_S & rop3_D) is the rop3 code for S & D.  We just have to remember
  42.  * to mask results with rop2_1 or rop3_1 if necessary.
  43.  */
  44.  
  45. /* 2-input RasterOp */
  46. typedef enum {
  47.     rop2_0 = 0,
  48.     rop2_S = 0xc,        /* source */
  49. #define rop2_S_shift 2
  50.     rop2_D = 0xa,        /* destination */
  51. #define rop2_D_shift 1
  52.     rop2_1 = 0xf,
  53. #define rop2_operand(shift, d, s)\
  54.   ((shift) == 2 ? (s) : (d))
  55.     rop2_default = rop2_S
  56. } gs_rop2_t;
  57.  
  58. /*
  59.  * For the 3-input case, we follow H-P's inconsistent terminology:
  60.  * the transparency mode is called pattern transparency, but the third
  61.  * RasterOp operand is called texture, not pattern.
  62.  */
  63.  
  64. /* 3-input RasterOp */
  65. typedef enum {
  66.     rop3_0 = 0,
  67.     rop3_T = 0xf0,        /* texture */
  68. #define rop3_T_shift 4
  69.     rop3_S = 0xcc,        /* source */
  70. #define rop3_S_shift 2
  71.     rop3_D = 0xaa,        /* destination */
  72. #define rop3_D_shift 1
  73.     rop3_1 = 0xff,
  74.     rop3_default = rop3_T | rop3_S
  75. } gs_rop3_t;
  76.  
  77. /* All the transformations on rop3s are designed so that */
  78. /* they can also be used on lops.  The only place this costs anything */
  79. /* is in rop3_invert. */
  80.  
  81. /*
  82.  * Invert an operand.
  83.  */
  84. #define rop3_invert_(op, mask, shift)\
  85.   ( (((op) & mask) >> shift) | (((op) & (rop3_1 - mask)) << shift) |\
  86.     ((op) & ~rop3_1) )
  87. #define rop3_invert_D(op) rop3_invert_(op, rop3_D, rop3_D_shift)
  88. #define rop3_invert_S(op) rop3_invert_(op, rop3_S, rop3_S_shift)
  89. #define rop3_invert_T(op) rop3_invert_(op, rop3_T, rop3_T_shift)
  90. /*
  91.  * Pin an operand to 0.
  92.  */
  93. #define rop3_know_0_(op, mask, shift)\
  94.   ( (((op) & (rop3_1 - mask)) << shift) | ((op) & ~mask) )
  95. #define rop3_know_D_0(op) rop3_know_0_(op, rop3_D, rop3_D_shift)
  96. #define rop3_know_S_0(op) rop3_know_0_(op, rop3_S, rop3_S_shift)
  97. #define rop3_know_T_0(op) rop3_know_0_(op, rop3_T, rop3_T_shift)
  98. /*
  99.  * Pin an operand to 1.
  100.  */
  101. #define rop3_know_1_(op, mask, shift)\
  102.   ( (((op) & mask) >> shift) | ((op) & ~(rop3_1 - mask)) )
  103. #define rop3_know_D_1(op) rop3_know_1_(op, rop3_D, rop3_D_shift)
  104. #define rop3_know_S_1(op) rop3_know_1_(op, rop3_S, rop3_S_shift)
  105. #define rop3_know_T_1(op) rop3_know_1_(op, rop3_T, rop3_T_shift)
  106. /*
  107.  * Swap S and T.
  108.  */
  109. #define rop3_swap_S_T(op)\
  110.   ( (((op) & rop3_S & ~rop3_T) << (rop3_T_shift - rop3_S_shift)) |\
  111.     (((op) & ~rop3_S & rop3_T) >> (rop3_T_shift - rop3_S_shift)) |\
  112.     ((op) & (~rop3_1 | (rop3_S ^ rop3_T))) )
  113. /*
  114.  * Account for transparency.
  115.  */
  116. #define rop3_use_D_when_0_(op, mask)\
  117.   (((op) & ~(rop3_1 - mask)) | (rop3_D & ~mask))
  118. #define rop3_use_D_when_1_(op, mask)\
  119.   (((op) & ~mask) | (rop3_D & mask))
  120. #define rop3_use_D_when_S_0(op) rop3_use_D_when_0_(op, rop3_S)
  121. #define rop3_use_D_when_S_1(op) rop3_use_D_when_1_(op, rop3_S)
  122. #define rop3_use_D_when_T_0(op) rop3_use_D_when_0_(op, rop3_T)
  123. #define rop3_use_D_when_T_1(op) rop3_use_D_when_1_(op, rop3_T)
  124. /*
  125.  * Invert the result.
  126.  */
  127. #define rop3_not(op) ((op) ^ rop3_1)
  128. /*
  129.  * Test whether an operand is used.
  130.  */
  131. #define rop3_uses_(op, mask, shift)\
  132.   ( ((((op) << shift) ^ (op)) & mask) != 0 )
  133. #define rop3_uses_D(op) rop3_uses_(op, rop3_D, rop3_D_shift)
  134. #define rop3_uses_S(op) rop3_uses_(op, rop3_S, rop3_S_shift)
  135. #define rop3_uses_T(op) rop3_uses_(op, rop3_T, rop3_T_shift)
  136. /*
  137.  * Test whether an operation is idempotent, i.e., whether
  138.  * f(D, S, T) = f(f(D, S, T), S, T).  This is equivalent to the condition that
  139.  * for all values s and t, !( f(0,s,t) == 1 && f(1,s,t) == 0 ).
  140.  */
  141. #define rop3_is_idempotent(op)\
  142.   !( (op) & ~((op) << rop3_D_shift) & rop3_D )
  143.  
  144. /* Transparency */
  145. #define source_transparent_default false
  146. #define pattern_transparent_default false
  147.  
  148. /*
  149.  * We define a logical operation as a RasterOp, transparency flags,
  150.  * and render algorithm all packed into a single integer.
  151.  * In principle, we should use a structure, but most C implementations
  152.  * implement structure values very inefficiently.
  153.  */
  154. #define lop_rop(lop) ((gs_rop3_t)((lop) & 0xff))    /* must be low-order bits */
  155. #define lop_S_transparent 0x100
  156. #define lop_T_transparent 0x200
  157. #define lop_ral_shift 10
  158. #define lop_ral_mask 0xf
  159. typedef uint gs_logical_operation_t;
  160.  
  161. #define lop_default\
  162.   (rop3_default |\
  163.    (source_transparent_default ? lop_S_transparent : 0) |\
  164.    (pattern_transparent_default ? lop_T_transparent : 0))
  165.  
  166.      /* Test whether a logical operation uses S or T. */
  167. #ifdef TRANSPARENCY_PER_H_P    /* bizarre but necessary definition */
  168. #define lop_uses_S(lop)\
  169.   (rop3_uses_S(lop) || ((lop) & (lop_S_transparent | lop_T_transparent)))
  170. #else                /* reasonable definition */
  171. #define lop_uses_S(lop)\
  172.   (rop3_uses_S(lop) || ((lop) & lop_S_transparent))
  173. #endif
  174. #define lop_uses_T(lop)\
  175.   (rop3_uses_T(lop) || ((lop) & lop_T_transparent))
  176. /* Test whether a logical operation just sets D = x if y = 0. */
  177. #define lop_no_T_is_S(lop)\
  178.   (((lop) & (lop_S_transparent | (rop3_1 - rop3_T))) == (rop3_S & ~rop3_T))
  179. #define lop_no_S_is_T(lop)\
  180.   (((lop) & (lop_T_transparent | (rop3_1 - rop3_S))) == (rop3_T & ~rop3_S))
  181. /* Test whether a logical operation is idempotent. */
  182. #define lop_is_idempotent(lop) rop3_is_idempotent(lop)
  183.  
  184. /*
  185.  * Define the logical operation versions of some RasterOp transformations.
  186.  * Note that these also affect the transparency flags.
  187.  */
  188. #define lop_know_S_0(lop)\
  189.   (rop3_know_S_0(lop) & ~lop_S_transparent)
  190. #define lop_know_T_0(lop)\
  191.   (rop3_know_T_0(lop) & ~lop_T_transparent)
  192. #define lop_know_S_1(lop)\
  193.   (lop & lop_S_transparent ? rop3_D : rop3_know_S_1(lop))
  194. #define lop_know_T_1(lop)\
  195.   (lop & lop_T_transparent ? rop3_D : rop3_know_T_1(lop))
  196.  
  197. /* Define the interface to the table of 256 RasterOp procedures. */
  198. typedef unsigned long rop_operand;
  199. typedef rop_operand (*rop_proc)(P3(rop_operand D, rop_operand S, rop_operand T));
  200.  
  201. /* Define the table of operand usage by the 256 RasterOp operations. */
  202. typedef enum {
  203.     rop_usage_none = 0,
  204.     rop_usage_D = 1,
  205.     rop_usage_S = 2,
  206.     rop_usage_DS = 3,
  207.     rop_usage_T = 4,
  208.     rop_usage_DT = 5,
  209.     rop_usage_ST = 6,
  210.     rop_usage_DST = 7
  211. } rop_usage_t;
  212.  
  213. /* Define the table of RasterOp implementation procedures. */
  214. extern const rop_proc rop_proc_table[256];
  215.  
  216. /* Define the table of RasterOp operand usage. */
  217. extern const byte /*rop_usage_t*/ rop_usage_table[256];
  218.  
  219. #endif /* gsropt_INCLUDED */
  220.